#include "Serial_RX.h"

/*角度传感器变量定义*/
struct SAcc 		stcAcc;
struct SGyro 		stcGyro;
struct SAngle 	stcAngle;

//每个串口需要设置一次，接收不定长的数据，只接收~与0D0A之间的数据
/**************************************************************************
函数功能：串口1接收函数，帧头-‘~’，帧尾-“\r\n”
入口参数：串口1接收的单字节数据
返回  值：无
**************************************************************************/
void UART1_Receive(uint8_t RXBUF)
{
    uint16_t UART1_Max_Recv_Len = 40;                           //最大接收长度
    static uint16_t UART1_STA = 0;                          //数据长度计数，同时用最后一位表示接收0A,倒数第二位表示接收0D
    static uint8_t UART1_RX_BUF[20],Uart_FLag= 0;
		RXBUF == '~' ? Uart_FLag = 1 :0;
    if((UART1_STA&0x8000)==0 && Uart_FLag)                      //未接收到0D0A
    {
        if(UART1_STA&0x4000)                                    //上一位接收到0x0d
        {
            if(RXBUF!=0x0a)UART1_STA=0;                         //接收到0D后下一位不是0A,重新开始
            else UART1_STA|=0x8000;                             //接收到0X0A
        }
        else                                                    //还没收到0X0D
        {
            if(RXBUF==0x0d)UART1_STA|=0x4000;                   //接收到0X0D
            else
            {
                if(RXBUF!=0x0A && RXBUF!=' ')
                {
                    UART1_RX_BUF[UART1_STA&0X3FFF]=RXBUF;         //存储数据
                    UART1_STA++;
                }                                 //接收数据计数
                if(UART1_STA>(UART1_Max_Recv_Len-1))UART1_STA=0;//接收数据长度错误,重新开始接收
            }
        }
    }                                                           //接收到0D0A，处理通信数据
    if(UART1_STA&0x8000 && UART1_STA&0x4000 && Uart_FLag)
    {
        //处理函数//
        UART1Data_Process(UART1_RX_BUF,UART1_STA&0X3FFF);
        UART1_STA = 0;   
				Uart_FLag = 0; 
    }
}

/**************************************************************************
函数功能：串口2接收函数，帧头-‘~’，帧尾-“\r\n”
入口参数：串口2接收的单字节数据
返回  值：无
**************************************************************************/
void UART2_Receive(uint8_t RXBUF)
{
	uint16_t UART2_Max_Recv_Len = 20;                           //最大接收长度
	static uint16_t UART2_STA = 0;                              //数据长度计数，同时用最后一位表示接收0A,倒数第二位表示接收0D
	static uint8_t UART2_RX_BUF[20],Uart_FLag = 0;
	RXBUF == '~' ? Uart_FLag = 1 : 0;
	if((UART2_STA&0x8000)==0 && Uart_FLag)                      //未接收到0D0A[只有0D不能使用，0A和~在第一个~和0D之间可以使用]
	{
			if(UART2_STA&0x4000)                                    //上一位接收到0x0d
			{
					if(RXBUF!=0x0a)UART2_STA=0;                         //接收到0D后下一位不是0A,重新开始
					else UART2_STA|=0x8000;                             //接收到0X0A
			}
			else                                                    //还没收到0X0D
			{
					if(RXBUF==0x0d)UART2_STA|=0x4000;                   //接收到0X0D
					else
					{
							if(RXBUF!=0x0A && RXBUF!=' ')
							{
									UART2_RX_BUF[UART2_STA&0X3FFF]=RXBUF;         //存储数据
									UART2_STA++;
							}                                 //接收数据计数
							if(UART2_STA>(UART2_Max_Recv_Len-1))UART2_STA=0;//接收数据长度错误,重新开始接收
					}
			}
	}                                                           //接收到0D0A，处理通信数据
	if(UART2_STA&0x8000 && UART2_STA&0x4000 && Uart_FLag)
	{
		//处理函数//
		UART2Data_Process(UART2_RX_BUF,UART2_STA&0X3FFF);
		UART2_STA = 0;                                          //处理完成，计数清零
		Uart_FLag = 0;
	}
}

/**************************************************************************
函数功能：串口3接收函数，帧头-‘~’，帧尾-“\r\n”
入口参数：串口3接收的单字节数据
返回  值：无
**************************************************************************/
void UART3_Receive(uint8_t RXBUF)
{
	uint16_t UART3_Max_Recv_Len = 20;                           //最大接收长度
	static uint16_t UART3_STA = 0;                              //数据长度计数，同时用最后一位表示接收0A,倒数第二位表示接收0D
	static uint8_t UART3_RX_BUF[20],Uart_FLag = 0;
	RXBUF == '~' ? Uart_FLag = 1 : 0;
	if((UART3_STA&0x8000)==0 && Uart_FLag)                      //未接收到0D0A[只有0D不能使用，0A和~在第一个~和0D之间可以使用]
	{
			if(UART3_STA&0x4000)                                    //上一位接收到0x0d
			{
					if(RXBUF!=0x0a)UART3_STA=0;                         //接收到0D后下一位不是0A,重新开始
					else UART3_STA|=0x8000;                             //接收到0X0A
			}
			else                                                    //还没收到0X0D
			{
					if(RXBUF==0x0d)UART3_STA|=0x4000;                   //接收到0X0D
					else
					{
							if(RXBUF!=0x0A && RXBUF!=' ')
							{
									UART3_RX_BUF[UART3_STA&0X3FFF]=RXBUF;         //存储数据
									UART3_STA++;
							}                                 //接收数据计数
							if(UART3_STA>(UART3_Max_Recv_Len-1))UART3_STA=0;//接收数据长度错误,重新开始接收
					}
			}
	}                                                           //接收到0D0A，处理通信数据
	if(UART3_STA&0x8000 && UART3_STA&0x4000 && Uart_FLag)
	{
		//处理函数//
		UART3Data_Process(UART3_RX_BUF,UART3_STA&0X3FFF);
		UART3_STA = 0;                                          //处理完成，计数清零
		Uart_FLag = 0;
	}
}

/**************************************************************************
函数功能：串口接收数据处理函数，通过特定协议修改3轴速度
入口参数：串口接收的一段数据与其长度
返回  值：无
**************************************************************************/
int UART1Data_Process(uint8_t *UART_RX_BUF,uint16_t UART_STA)
{
		char i = 0;
		for(i=0;i<UART_STA;i++)
		{
			switch(UART_RX_BUF[i])
			{
				case 'L':
					L_state = CharToNum(&UART_RX_BUF[i+1],UART_STA-i-1);
					armstart = 1;
					break;
				case 'R':
					R_state = CharToNum(&UART_RX_BUF[i+1],UART_STA-i-1);
					armstart = 1;
					break;
				//C区向前抓取
				case 'F':
					F_state = CharToNum(&UART_RX_BUF[i+1],UART_STA-i-1);
					armstart = 1;
					break;
				//D区向前抓取
				case 'G':
					G_state = CharToNum(&UART_RX_BUF[i+1],UART_STA-i-1);
					armstart = 1;
					break;			
				//D区收集
				case 'g':
					g_state = CharToNum(&UART_RX_BUF[i+1],UART_STA-i-1);
					armstart = 1;
					break;					
				//向前看
				case 'K':
					Look_state = CharToNum(&UART_RX_BUF[i+1],UART_STA-i-1);
					armstart = 1;
					break;
				//B区左右识别成熟度
				case 'A':
					L_GrapLook_state = CharToNum(&UART_RX_BUF[i+1],UART_STA-i-1);
					armstart = 1;
					break;
				case 'D':
					R_GrapLook_state = CharToNum(&UART_RX_BUF[i+1],UART_STA-i-1);
					armstart = 1;
					break;
				case 'S':
					if(armstart == 0) armstart = 2;
					break;
				case 'H':
					Horizon_state = CharToNum(&UART_RX_BUF[i+1],UART_STA-i-1);
					if(Horizon_state<=180&&Horizon_state>=0) armstart = 1;
					break;
				default:
					break;
			}		
		}

    return 0;
}

int UART2Data_Process(uint8_t *UART_RX_BUF,uint16_t UART_STA)
{
		char i = 0;
		for(i=0;i<UART_STA;i++)
		{
			switch(UART_RX_BUF[i])
			{
					default:break;
			}		
		}
    return 0;
}

int UART3Data_Process(uint8_t *UART_RX_BUF,uint16_t UART_STA)
{
		char i = 0;
		for(i=0;i<UART_STA;i++)
		{
			switch(UART_RX_BUF[i])
			{
				case 'L':
					L_state = CharToNum(&UART_RX_BUF[i+1],UART_STA-i-1);
					armstart = 1;
					break;
				case 'R':
					R_state = CharToNum(&UART_RX_BUF[i+1],UART_STA-i-1);
					armstart = 1;
					break;
				//C区向前抓取
				case 'F':
					F_state = CharToNum(&UART_RX_BUF[i+1],UART_STA-i-1);
					armstart = 1;
					break;
				//D区向前抓取
				case 'G':
					G_state = CharToNum(&UART_RX_BUF[i+1],UART_STA-i-1);
					armstart = 1;
					break;	
				//D区收集
				case 'g':
					g_state = CharToNum(&UART_RX_BUF[i+1],UART_STA-i-1);
					armstart = 1;
					break;
				//向前看
				case 'K':
					Look_state = CharToNum(&UART_RX_BUF[i+1],UART_STA-i-1);
					armstart = 1;
					break;
				//B区左右识别成熟度
				case 'A':
					L_GrapLook_state = CharToNum(&UART_RX_BUF[i+1],UART_STA-i-1);
					armstart = 1;
					break;
				case 'D':
					R_GrapLook_state = CharToNum(&UART_RX_BUF[i+1],UART_STA-i-1);
					armstart = 1;
					break;
				case 'S':
					if(armstart == 0) armstart = 2;
					break;
				case 'H':
					Horizon_state = CharToNum(&UART_RX_BUF[i+1],UART_STA-i-1);
					if(Horizon_state<=180&&Horizon_state>=0) armstart = 1;
					break;
				default:
					break;
			}		
		}
    return 0;
}
/**************************************************************************
函数功能：
入口参数：
返回  值：
**************************************************************************/
int DataS_Process(uint8_t *UART_RX_BUF,uint16_t UART_STA)
{
		u8 i = 0,j = 0,k = 0;		//数组的位数、数据的个数 
		u8 Data_STA[10];		//记录第j个数据最后一位的位置
		for(i=0;i<UART_STA;i++)
		{
			switch(UART_RX_BUF[i])
			{
					case '~':	
						/*记录i，第j个数据'~'的位置，第0个数据=0*/
						Data_STA[j] = i;
						/*'~'的个数，共j个数*/
						j++;
						break;
					default:break;
			}		
		}
		Data_STA[j] = UART_STA;		
		/*给j个数据进行赋值*/
		for(i=0;i<j;i++)
		{
			for(k=Data_STA[i];k<Data_STA[i+1];k++)
			{
				switch(UART_RX_BUF[k])
				{
					default:
						break;					
				}
			}
		}
    return 0;
}
/**************************************************************************
函数功能：将字符形的数字转为float类型
入口参数：特定字母后的字符数字及其长度
返回  值：转换后的数字
**************************************************************************/
float CharToNum(uint8_t *cData,uint8_t len)
{
    uint8_t i=0,dot_count = 0;
    int Num_Return = 0,Num_cnt = 1,Num_Receive;
    for(i=1;i<len+1;i++)
    {
			Num_Receive = *cData-'0';
			switch(dot_count)
			{
					case 0:
						switch(*cData)
						{
								case '.':
									dot_count++;
									break;
								case '-':
									Num_cnt *= -1;
									break;
								default:
									if(Num_Receive>9 || Num_Receive<0) return 0;
									Num_Return = Num_Return*10+Num_Receive;
									break;
						}
						break;
					case 1:
						if(*cData=='.')			//接收到多个‘.’
								return 0;
						else
						{
							if(Num_Receive>9 || Num_Receive<0) return 0;
									Num_Return = Num_Return*10+Num_Receive;
							Num_cnt*=10;
						}							
						break;
					default:
						return 0;
			}
			cData++;
    }
    return Num_Return/1.0/Num_cnt;
}

///**************************************************************************
//函数功能：jy901数据处理函数
//入口参数：串口3接收的单个字节
//返回  值：无
//**************************************************************************/
//void CopeSerial2Data(unsigned char ucData)
//{
//	static unsigned char ucRxBuffer[250];
//	static unsigned char ucRxCnt = 0;	
//	
////	LED_REVERSE();					//接收到数据，LED灯闪烁一下
//	ucRxBuffer[ucRxCnt++]=ucData;	//将收到的数据存入缓冲区中
//	if (ucRxBuffer[0]!=0x55) //数据头不对，则重新开始寻找0x55数据头
//	{
//		ucRxCnt=0;
//		return;
//	}
//	if (ucRxCnt<11) {return;}//数据不满11个，则返回
//	else
//	{
//		switch(ucRxBuffer[1])//判断数据是哪种数据，然后将其拷贝到对应的结构体中，有些数据包需要通过上位机打开对应的输出后，才能接收到这个数据包的数据
//		{
//			//memcpy为编译器自带的内存拷贝函数，需引用"string.h"，将接收缓冲区的字符拷贝到数据结构体里面，从而实现数据的解析。
//			case 0x51:	memcpy(&stcAcc,&ucRxBuffer[2],8);break;
//			case 0x52:	memcpy(&stcGyro,&ucRxBuffer[2],8);break;
//			case 0x53:	memcpy(&stcAngle,&ucRxBuffer[2],8);break;

//		}
//		ucRxCnt=0;//清空缓存区
//	}
//}
